package com.bdqn;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.InputMismatchException;
import java.util.Map;

public class SimpleBeanConvertor {
    private static Logger logger = LogManager.getLogger(SimpleBeanConvertor.class);
    public static <T>T convert(HttpServletRequest request, Class<T> targetType)throws IllegalAccessException, InstantiationException,
            UnsupportedTypeException,InputMismatchException{
        //获取所有的请求参数
        Map<String,String[]> params = request.getParameterMap();
        if (params.size()==0){
            return null;
        }
        T target = targetType.newInstance();        //创建实例

        //获取JavaBean中所有的方法
            Method[] allMethods = targetType.getMethods();
            if (allMethods != null && allMethods.length > 0){
                for (Method method: allMethods){
                    if (method.getName().startsWith("set")){    //仅处理setter访问器
                        Class[] args = method.getExceptionTypes();  //获取参数列表
                        if (args.length == 1){      //仅处理单参情况
                            //获取set方法对应的请求参数： setName-->name
                            String paramName = method.getName().substring(3,4).toLowerCase()+method.getName().substring(4);
                            if (params.containsKey(paramName)){     //请求中有此参数
                                try {
                                    Object value = parseValue(params.get(paramName),args[0]);
                                    try {
                                        method.invoke(target,value);
                                    } catch (InvocationTargetException e) {
                                        e.printStackTrace();
                                    }
                                } catch (ParseException e) {
                                    logger.debug("参数转换错误",e);
                                    e.printStackTrace();
                                    try {
                                        throw e;
                                    } catch (ParseException parseException) {
                                        parseException.printStackTrace();
                                    }
                                }
                            }else if (Boolean.class == args[0] || boolean.class == args[0]){
                                //如果是boolean，不存在表示false
                                try {
                                    method.invoke(target,false);
                                } catch (InvocationTargetException e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                    }
                }
            }
        return target;
    }

    private static Object parseValue(String[] value,Class type) throws ParseException, UnsupportedTypeException {
        if(String.class == type){
            return value[0];
        }
        if (java.util.Date.class == type) {
            return new SimpleDateFormat("yyyy-MM-dd").parse(value[0]);
        }
        if (boolean.class == type || Boolean.class == type){
            return true;
        }
        if (char.class == type || Character.class == type){
            return value[0].charAt(0);
        }
        if (int.class == type || Integer.class == type){
            return Integer.valueOf(value[0]);
        }
        if (short.class == type || byte.class==type || long.class == type || float.class == type || double.class == type){
            try {
                type = Class.forName("java.lang."+type.getName().substring(0,1).toUpperCase()+type.getName().substring(1));
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            if (type.getName().startsWith("java.lang.") || type.getName().startsWith("java.math")){
                try {
                    return type.getConstructor(String.class).newInstance(value[0]);
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                }

                    throw new UnsupportedTypeException();
            }
        }
        return null;
    }
}
